home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
boe.pres.k12.wv.us
/
boe.pres.k12.wv.us.zip
/
boe.pres.k12.wv.us
/
Utilities
/
Xerox Workcentre 5335
/
Windows Scan
/
32-bit_x86
/
Francais
/
cpsimage.cab
/
data
/
xps
/
XpsResource.elf
< prev
next >
Wrap
Text File
|
2009-03-16
|
12KB
|
364 lines
#import "builtins.ucm"; /* for: GetDataResource */
#import "documentio.ucm"; /* for: XIPXMLtoXPSXML */
#load "docio/xmldocutils.elf"; /* XIPXML_COALESCEWORDS support */
#load "xps/Xps.elf";
#load "xps/XpsPackagePart.elf";
#load "xps/XpsAttrs.elf";
/******************************************************************************/
CLASS XpsResource EXTENDS XpsPackagePart {
// Fields
STRING id;
STRING mimeType;
STRING typeUri;
STRING ext;
BOOLEAN shared;
// Methods
METHOD isShared () RETURNS (BOOLEAN value) {
value = this.shared;
}
METHOD setShared (BOOLEAN value) {
this.shared = value;
}
METHOD getId () RETURNS (STRING id) {
id = this.id;
}
METHOD getMimeType () RETURNS (STRING mimeType) {
mimeType = this.mimeType;
}
METHOD getMimeDataType () RETURNS (STRING type) {
type = this.mimeType.split (delims: "/").ref (entry: 0);
}
METHOD getMimeDataSubtype () RETURNS (STRING subtype) {
subtype = this.mimeType.split (delims: "/").ref (entry: 1);
}
METHOD getTypeUri () RETURNS (STRING typeUri) {
typeUri = this.typeUri;
}
METHOD makeUri (INTEGER docNum, INTEGER pgNum) {
}
METHOD write (STRING filename) {
}
}
/******************************************************************************/
CLASS XpsImage EXTENDS XpsResource {
// Fields
XIPIMAGE layer;
INTEGER layerNum;
// Methods
METHOD getMember (STRING member)
RETURNS (OBJECT obj) {
obj = this.layer.getMember (num: this.layerNum, member: member);
}
METHOD makeUri (INTEGER docNum, INTEGER pgNum)
RETURNS (STRING uri) {
STRING basename;
if (!this.shared) {
if ((docNum <= 0) || (pgNum <= 0)) {
SetStatus (op: "stop", msg: "ArgumentException");
return;
}
uri = Xps.DOCS_PATH + "/" + docNum;
basename = "Page" + pgNum + "_Layer" + this.layerNum;
}
else {
basename = this.id;
}
uri = uri + Xps.RESOURCES_PATH + Xps.IMAGES_PATH +
"/" + basename + "." + this.ext;
}
METHOD write (STRING filename) {
LoadClasses (filename: "xeng");
XIPIMAGE imgL = this.layer.getLayer (num: 0);
INTEGER ltype = this.layer.getMember (num: 0,
member: "layerType");
INTEGER comp = this.layer.getMember (num: 0,
member: "compression");
FILE dir = new (FILE, path: filename).getParentFile ();
if (!dir.exists ())
dir.mkdirs ();
if (ltype == XIP_Contone || comp == XIP_JPEG_COMP) {
// This handles PDF cascaded compression of Jpeg followed with deflate
if (comp != XIP_JPEG_COMP)
imgL = imgL.unCompress ();
if (this.ext.strcasecmp (str: "jpg"))
imgL.writejpgop (filename: filename);
else if (this.ext.strcasecmp (str: "wdp"))
imgL.writehdpop (filename: filename);
else {
print "XpsImage: Error, not configured for writing " + this.ext +
" file for contone and/or jpeg-compressed layer";
return;
}
}
else if ( ltype == XIP_ColorMask || ltype == XIP_Binary || ltype == XIP_ContoneMask) {
if (ltype == XIP_ColorMask || ltype == XIP_ContoneMask) {
imgL = imgL.unCompress ();
if ( imgL.getMember (member: "photometry") == XIP_K_COLOR )
imgL = imgL.invert();
imgL = imgL.modheader (modify: ("Photometry:transparency:0"));
}
else
imgL = imgL.unCompress();
/*
** For now set the resolution to 0 in order to prevent XPS viewer
** from using it
*/
if (this.ext.strcasecmp (str: "tif"))
imgL.writetifop (filename: filename, ccitt: 4, noicc:TRUE);
else if (this.ext.strcasecmp (str: "png"))
imgL.writepng (filename: filename);
else {
print "XpsImage: Error, not configured for writing " + this.ext +
" file for binary or mask layer";
return;
}
}
Execute ();
}
}
/******************************************************************************/
CLASS XpsThumbnail EXTENDS XpsResource {
// Fields
XIPIMAGE layer;
// Methods
METHOD makeUri (INTEGER docNum, INTEGER pgNum)
RETURNS (STRING uri) {
STRING basename;
if (!this.shared) {
if ((docNum <= 0) || (pgNum <= 0)) {
SetStatus (op: "stop", msg: "ArgumentException");
return;
}
uri = Xps.DOCS_PATH + "/" + docNum;
basename = "Page" + pgNum + "_Thumb";
}
else {
basename = "Package_Thumb";
}
uri = uri + Xps.METADATA_PATH +
"/" + basename + "." + this.ext;
}
METHOD write (STRING filename) {
LoadClasses (filename: "xeng");
FILE dir = new (FILE, path: filename).getParentFile ();
if (!dir.exists ())
dir.mkdirs ();
// The delete was put in place to avoid changing checksums when units
// were allowed again
this.layer.modheader (_delete: ("Origin:units")
).writejpgop (filename: filename
);
Execute ();
}
}
/******************************************************************************/
CLASS XpsFont EXTENDS XpsResource {
// Fields
STRING basename;
// Methods
METHOD makeUri (INTEGER docNum, INTEGER pgNum)
RETURNS (STRING uri) {
if (!this.shared) {
if ((docNum <= 0) || (pgNum <= 0)) {
SetStatus (op: "stop", msg: "ArgumentException");
return;
}
uri = Xps.DOCS_PATH + "/" + docNum;
}
uri = uri + Xps.RESOURCES_PATH + Xps.FONTS_PATH +
"/" + this.basename + "." + this.ext;
}
METHOD write (STRING filename) {
STRING fname = this.basename + "." + this.ext;
STRING fontPath = GetDataResource (filename: "xps/Fonts/" + fname);
if (!fontPath) {
SetStatus (op: "stop", msg: "FileNotFoundException");
return;
}
FILE dir = new (FILE, path: filename).getParentFile ();
if (!dir.exists ())
dir.mkdirs ();
System (cmd: "cp " + fontPath + " " + filename);
}
}
/******************************************************************************/
CLASS XpsResourceFactory {
METHOD createResource (XIPIMAGE img, INTEGER layerNum)
RETURNS (XpsResource res) {
INTEGER ltype = img.getMember (num: layerNum, member: "layerType");
if (ltype == XIP_Text) {
res = this.createFont (img: img, layerNum: layerNum);
}
else if (ltype == XIP_Thumbnail) {
res = this.createThumbnail (img: img, layerNum: layerNum);
}
else if (ltype == XIP_Binary || ltype == XIP_Contone ||
ltype == XIP_ColorMask || ltype == XIP_ContoneMask) {
res = this.createImage (img: img, layerNum: layerNum);
}
}
METHOD createResources (XIPIMAGE img)
RETURNS (LIST resources) {
XpsResource res;
INTEGER i;
for (i = 0; i < img.nlayers; i++) {
res = this.createResource (img: img, layerNum: i);
if (res)
resources.insert (obj: res, entry: resources.length ());
}
}
METHOD createImage (XIPIMAGE img, INTEGER layerNum)
RETURNS (XpsImage image) {
XIPIMAGE layer = img.getLayer (num: layerNum);
image.id = "Image_" + MD5 (obj: layer);
image.shared = FALSE;
image.ext = this.mapExt (img: img, layerNum: layerNum);
image.layer = layer;
image.layerNum = layerNum.Copy ();
image.typeUri = Xps.REQUIRED_RESOURCE_URI;
image.mimeType = this.mapMimeType (ext: image.ext);
}
METHOD createThumbnail (XIPIMAGE img, INTEGER layerNum)
RETURNS (XpsThumbnail thumb) {
XIPIMAGE layer = img.getLayer (num: layerNum);
thumb.id = "Thumbnail" + MD5 (obj: layer);
thumb.shared = FALSE;
thumb.ext = "jpg";
thumb.layer = layer;
thumb.typeUri = Xps.RELS_THUMBNAIL_URI;
thumb.mimeType = this.mapMimeType (ext: thumb.ext);
}
METHOD createFont (XIPIMAGE img, INTEGER layerNum)
RETURNS (XpsFont font) {
DOUBLE fx = 96 / img.resolution[0];
DOUBLE fy = 96 / img.resolution[1];
XIPIMAGE layer = img.getLayer (num: layerNum);
INTEGER txtfmt = layer.getMember (member: "textformat");
if (txtfmt != XIP_XML_TEXT) {
print "Invalid text layer format type to include in XPS";
continue;
}
STRING xipocr = layer.getMember(member:"text");
STRING ocrxml, filename;
if (img.getAttr (name: "XpsAttrs").doCoalesce) {
/* May need to override the default tolerences some day */
xipocr = XIPXML_COALESCEWORDS.format (xipxml: xipocr);
}
DOUBLE xpos = layer.getMember (member: "xpos") * fx;
DOUBLE ypos = layer.getMember (member: "ypos") * fy;
DOUBLE width = layer.getMember (member: "width") * fx;
DOUBLE height = layer.getMember (member: "height") * fy;
DOUBLE xres = layer.getMember (member: "xres");
DOUBLE yres = layer.getMember (member: "yres");
LIST xform = layer.getAttr (name: "_DIOMatrixTransform", num: 0);
LIST coeffs;
if (!xform)
coeffs = (1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
else {
TRANSFORM2D matrix;
matrix.setCoeffs (coeffs: xform);
coeffs = matrix.getCoeffs ();
coeffs[4] *= fx;
coeffs[5] *= fy;
}
XIPXMLtoXPSXML (xipxml: xipocr, width: width, height: height,
xres: xres, yres: yres, matrix: coeffs)
Returns (xpsxml: ocrxml, font: filename);
img.setAttr (name: "XpsGlyphs", obj: ocrxml);
STRING fontPath = GetDataResource (filename: "xps/Fonts/" + filename);
font.id = "Font" + MD5 (filename: fontPath);
font.shared = TRUE;
font.typeUri = Xps.REQUIRED_RESOURCE_URI;
font.ext = filename.ext ();
font.basename = filename.basename ();
INTEGER len = font.basename.length () - font.ext.length () - 1;
font.basename = font.basename.substring (start: 0, run: len);
if (font.ext.strcasecmp (str: "ttf"))
font.mimeType = Xps.TTF_TYPE;
else
font.mimeType = Xps.ODTTF_TYPE;
}
METHOD mapMimeType (STRING ext)
RETURNS (STRING mimeType) {
if (ext.strcasecmp (str: "jpg"))
mimeType = Xps.JPEG_TYPE;
else if (ext.strcasecmp (str: "tif"))
mimeType = Xps.TIFF_TYPE;
else
mimeType = Xps.PNG_TYPE;
}
METHOD mapExt (XIPIMAGE img, INTEGER layerNum)
RETURNS (STRING ext) {
INTEGER ltype = img.getMember (num: layerNum, member: "layerType");
INTEGER comp = img.getMember (num: layerNum, member: "compression");
if (ltype == XIP_Contone || comp == XIP_JPEG_COMP) {
ext = "jpg";
if (img.getAttr (name: "XpsAttrs").isJPEGXR)
ext = "wdp";
}
else {
ext = "png";
if (img.getAttr (name: "XpsAttrs").isTIFF && ltype != XIP_ColorMask)
ext = "tif";
}
}
}